{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T02:45:37.031224Z",
     "start_time": "2025-01-24T02:45:34.581764Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:17.243154Z",
     "iopub.status.busy": "2025-01-25T07:03:17.242928Z",
     "iopub.status.idle": "2025-01-25T07:03:22.112545Z",
     "shell.execute_reply": "2025-01-25T07:03:22.112087Z",
     "shell.execute_reply.started": "2025-01-25T07:03:17.243134Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=10, micro=14, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cu124\n",
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed_all(seed)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 准备数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T02:45:42.941686Z",
     "start_time": "2025-01-24T02:45:37.032228Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:22.113678Z",
     "iopub.status.busy": "2025-01-25T07:03:22.113365Z",
     "iopub.status.idle": "2025-01-25T07:03:27.771287Z",
     "shell.execute_reply": "2025-01-25T07:03:27.770799Z",
     "shell.execute_reply.started": "2025-01-25T07:03:22.113652Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2025-01-25 15:03:22.533691: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2025-01-25 15:03:22.760878: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:477] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
      "E0000 00:00:1737788602.848844     430 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "E0000 00:00:1737788602.873283     430 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2025-01-25 15:03:23.108921: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    }
   ],
   "source": [
    "from tensorflow import keras\n",
    "#用karas有的数据集imdb，电影分类,分电影是积极的，还是消极的\n",
    "imdb = keras.datasets.imdb\n",
    "#载入数据使用下面两个参数\n",
    "vocab_size = 10000  #词典大小，仅保留训练数据中前10000个最经常出现的单词，低频单词被舍弃\n",
    "index_from = 3  #0,1,2,3空出来做别的事\n",
    "#前一万个词出现词频最高的会保留下来进行处理，后面的作为特殊字符处理，\n",
    "# 小于3的id都是特殊字符，下面代码有写\n",
    "# 需要注意的一点是取出来的词表还是从1开始的，需要做处理\n",
    "(train_data, train_labels), (test_data, test_labels) = imdb.load_data(\n",
    "    num_words = vocab_size, index_from = index_from)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T02:45:42.945192Z",
     "start_time": "2025-01-24T02:45:42.941686Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:27.772567Z",
     "iopub.status.busy": "2025-01-25T07:03:27.772214Z",
     "iopub.status.idle": "2025-01-25T07:03:27.775365Z",
     "shell.execute_reply": "2025-01-25T07:03:27.774989Z",
     "shell.execute_reply.started": "2025-01-25T07:03:27.772538Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train 25000 (25000,)\n",
      "test 25000 (25000,)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print(\"train\", len(train_data), train_labels.shape)  #25000个样本，每个样本是一段话，每个单词用一个数字表示\n",
    "print(\"test\", len(test_data), test_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T02:45:42.992587Z",
     "start_time": "2025-01-24T02:45:42.945192Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:27.776033Z",
     "iopub.status.busy": "2025-01-25T07:03:27.775884Z",
     "iopub.status.idle": "2025-01-25T07:03:27.815867Z",
     "shell.execute_reply": "2025-01-25T07:03:27.815436Z",
     "shell.execute_reply.started": "2025-01-25T07:03:27.776018Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "88584\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "#载入词表，看下词表长度，词表就像英语字典\n",
    "word_index = imdb.get_word_index()\n",
    "print(len(word_index))\n",
    "print(type(word_index))\n",
    "#词表虽然有8万多，但是我们只载入了最高频的1万词！！！！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 构造 word2idx 和 idx2word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T02:45:43.010566Z",
     "start_time": "2025-01-24T02:45:42.993590Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:27.817309Z",
     "iopub.status.busy": "2025-01-25T07:03:27.816972Z",
     "iopub.status.idle": "2025-01-25T07:03:27.845561Z",
     "shell.execute_reply": "2025-01-25T07:03:27.844716Z",
     "shell.execute_reply.started": "2025-01-25T07:03:27.817292Z"
    }
   },
   "outputs": [],
   "source": [
    "word2idx = {word: idx + 3 for word, idx in word_index.items()}\n",
    "word2idx.update({\n",
    "    \"[PAD]\": 0,     # 填充 token\n",
    "    \"[BOS]\": 1,     # begin of sentence\n",
    "    \"[UNK]\": 2,     # 未知 token\n",
    "    \"[EOS]\": 3,     # end of sentence\n",
    "})\n",
    "\n",
    "idx2word = {idx: word for word, idx in word2idx.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T02:45:43.559166Z",
     "start_time": "2025-01-24T02:45:43.010566Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:27.846308Z",
     "iopub.status.busy": "2025-01-25T07:03:27.846114Z",
     "iopub.status.idle": "2025-01-25T07:03:28.709000Z",
     "shell.execute_reply": "2025-01-25T07:03:28.708578Z",
     "shell.execute_reply.started": "2025-01-25T07:03:27.846291Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 选择 max_length\n",
    "length_collect = {}\n",
    "for text in train_data:\n",
    "    length = len(text)\n",
    "    length_collect[length] = length_collect.get(length, 0) + 1\n",
    "    \n",
    "MAX_LENGTH = 500\n",
    "plt.bar(length_collect.keys(), length_collect.values())\n",
    "plt.axvline(MAX_LENGTH, label=\"max length\", c=\"gray\", ls=\":\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T02:45:43.568123Z",
     "start_time": "2025-01-24T02:45:43.559166Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:28.709839Z",
     "iopub.status.busy": "2025-01-25T07:03:28.709544Z",
     "iopub.status.idle": "2025-01-25T07:03:28.741490Z",
     "shell.execute_reply": "2025-01-25T07:03:28.741090Z",
     "shell.execute_reply.started": "2025-01-25T07:03:28.709822Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "raw text\n",
      "['hello', 'world']\n",
      "['tokenize', 'text', 'datas', 'with', 'batch']\n",
      "['this', 'is', 'a', 'test']\n",
      "indices\n",
      "tensor([   0,    0,    0,    1, 4825,  182,    3])\n",
      "tensor([    1,     2,  3004,     2,    19, 19233,     3])\n",
      "tensor([   0,    1,   14,    9,    6, 2181,    3])\n",
      "decode text\n",
      "[PAD] [PAD] [PAD] [BOS] hello world [EOS]\n",
      "[BOS] [UNK] text [UNK] with batch [EOS]\n",
      "[PAD] [BOS] this is a test [EOS]\n"
     ]
    }
   ],
   "source": [
    "class Tokenizer:\n",
    "    def __init__(self, word2idx, idx2word, max_length=500, pad_idx=0, bos_idx=1, eos_idx=3, unk_idx=2):\n",
    "        self.word2idx = word2idx\n",
    "        self.idx2word = idx2word\n",
    "        self.max_length = max_length\n",
    "        self.pad_idx = pad_idx\n",
    "        self.bos_idx = bos_idx\n",
    "        self.eos_idx = eos_idx\n",
    "        self.unk_idx = unk_idx\n",
    "    \n",
    "    def encode(self, text_list, padding_first=False):\n",
    "        \"\"\"如果padding_first == True，则padding加载前面，否则加载后面\"\"\"\n",
    "        max_length = min(self.max_length, 2 + max([len(text) for text in text_list]))\n",
    "        indices_list = []\n",
    "        for text in text_list:\n",
    "            indices = [self.bos_idx] + [self.word2idx.get(word, self.unk_idx) for word in text[:max_length-2]] + [self.eos_idx]\n",
    "            if padding_first:\n",
    "                indices = [self.pad_idx] * (max_length - len(indices)) + indices\n",
    "            else:\n",
    "                indices = indices + [self.pad_idx] * (max_length - len(indices))\n",
    "            indices_list.append(indices)\n",
    "        return torch.tensor(indices_list)\n",
    "    \n",
    "    \n",
    "    def decode(self, indices_list, remove_bos=True, remove_eos=True, remove_pad=True, split=False):\n",
    "        text_list = []\n",
    "        for indices in indices_list:\n",
    "            text = []\n",
    "            for index in indices:\n",
    "                word = self.idx2word.get(index, \"[UNK]\")\n",
    "                if remove_bos and word == \"[BOS]\":\n",
    "                    continue\n",
    "                if remove_eos and word == \"[EOS]\":\n",
    "                    break\n",
    "                if remove_pad and word == \"[PAD]\":\n",
    "                    break\n",
    "                text.append(word)\n",
    "            text_list.append(\" \".join(text) if not split else text)\n",
    "        return text_list\n",
    "    \n",
    "\n",
    "tokenizer = Tokenizer(word2idx=word2idx, idx2word=idx2word)\n",
    "raw_text = [\"hello world\".split(), \"tokenize text datas with batch\".split(), \"this is a test\".split()]\n",
    "indices = tokenizer.encode(raw_text, padding_first=True)\n",
    "decode_text = tokenizer.decode(indices.tolist(), remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "print(\"raw text\")\n",
    "for raw in raw_text:\n",
    "    print(raw)\n",
    "print(\"indices\")\n",
    "for index in indices:\n",
    "    print(index)\n",
    "print(\"decode text\")\n",
    "for decode in decode_text:\n",
    "    print(decode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T02:45:43.572116Z",
     "start_time": "2025-01-24T02:45:43.568123Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:28.742283Z",
     "iopub.status.busy": "2025-01-25T07:03:28.741962Z",
     "iopub.status.idle": "2025-01-25T07:03:28.745356Z",
     "shell.execute_reply": "2025-01-25T07:03:28.744979Z",
     "shell.execute_reply.started": "2025-01-25T07:03:28.742267Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"[BOS] this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert [UNK] is an amazing actor and now the same being director [UNK] father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for [UNK] and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also [UNK] to the two little boy's that played the [UNK] of norman and paul they were just brilliant children are often left out of the [UNK] list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all\",\n",
       " \"[BOS] big hair big boobs bad music and a giant safety pin these are the words to best describe this terrible movie i love cheesy horror movies and i've seen hundreds but this had got to be on of the worst ever made the plot is paper thin and ridiculous the acting is an abomination the script is completely laughable the best is the end showdown with the cop and how he worked out who the killer is it's just so damn terribly written the clothes are sickening and funny in equal [UNK] the hair is big lots of boobs [UNK] men wear those cut [UNK] shirts that show off their [UNK] sickening that men actually wore them and the music is just [UNK] trash that plays over and over again in almost every scene there is trashy music boobs and [UNK] taking away bodies and the gym still doesn't close for [UNK] all joking aside this is a truly bad film whose only charm is to look back on the disaster that was the 80's and have a good old laugh at how bad everything was back then\"]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 看看训练集的数据\n",
    "\n",
    "tokenizer.decode(train_data[:2], remove_bos=False, remove_eos=False, remove_pad=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据集与 DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T02:45:44.798941Z",
     "start_time": "2025-01-24T02:45:43.573121Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:28.746088Z",
     "iopub.status.busy": "2025-01-25T07:03:28.745803Z",
     "iopub.status.idle": "2025-01-25T07:03:30.782037Z",
     "shell.execute_reply": "2025-01-25T07:03:30.781569Z",
     "shell.execute_reply.started": "2025-01-25T07:03:28.746073Z"
    }
   },
   "outputs": [],
   "source": [
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "class IMDBDataset(Dataset):\n",
    "    def __init__(self, data, labels, remain_length=True):\n",
    "        if remain_length:\n",
    "            self.data = tokenizer.decode(data, remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "        else:\n",
    "            # 缩减一下数据\n",
    "            self.data = tokenizer.decode(data)\n",
    "        self.labels = labels\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        text = self.data[index]\n",
    "        label = self.labels[index]\n",
    "        return text, label\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "    \n",
    "    \n",
    "def collate_fct(batch):\n",
    "    text_list = [item[0].split() for item in batch]\n",
    "    label_list = [item[1] for item in batch]\n",
    "    # 这里使用 padding first\n",
    "    text_list = tokenizer.encode(text_list, padding_first=True).to(dtype=torch.int)\n",
    "    return text_list, torch.tensor(label_list).reshape(-1, 1).to(dtype=torch.float)\n",
    "\n",
    "\n",
    "# 用RNN，缩短序列长度\n",
    "train_ds = IMDBDataset(train_data, train_labels, remain_length=False)\n",
    "test_ds = IMDBDataset(test_data, test_labels, remain_length=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T02:45:44.802548Z",
     "start_time": "2025-01-24T02:45:44.799944Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:30.782775Z",
     "iopub.status.busy": "2025-01-25T07:03:30.782566Z",
     "iopub.status.idle": "2025-01-25T07:03:30.785620Z",
     "shell.execute_reply": "2025-01-25T07:03:30.785120Z",
     "shell.execute_reply.started": "2025-01-25T07:03:30.782756Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 128\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True, collate_fn=collate_fct)\n",
    "test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False, collate_fn=collate_fct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T02:45:44.821637Z",
     "start_time": "2025-01-24T02:45:44.803552Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:30.786400Z",
     "iopub.status.busy": "2025-01-25T07:03:30.786086Z",
     "iopub.status.idle": "2025-01-25T07:03:30.819868Z",
     "shell.execute_reply": "2025-01-25T07:03:30.819426Z",
     "shell.execute_reply.started": "2025-01-25T07:03:30.786385Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([128, 500]) torch.Size([128, 1])\n"
     ]
    }
   ],
   "source": [
    "for text, label in train_dl: #检查样本是否存在问题\n",
    "    print(text.shape, label.shape)\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T03:01:42.193751Z",
     "start_time": "2025-01-24T03:01:42.188880Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:30.820563Z",
     "iopub.status.busy": "2025-01-25T07:03:30.820342Z",
     "iopub.status.idle": "2025-01-25T07:03:30.829397Z",
     "shell.execute_reply": "2025-01-25T07:03:30.829013Z",
     "shell.execute_reply.started": "2025-01-25T07:03:30.820535Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================== 一层单向 LSTM ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "           lstm.weight_ih_l0            paramerters num: 4096\n",
      "           lstm.weight_hh_l0            paramerters num: 16384\n",
      "            lstm.bias_ih_l0             paramerters num: 256\n",
      "            lstm.bias_hh_l0             paramerters num: 256\n",
      "              layer.weight              paramerters num: 4096\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "source": [
    "class LSTM(nn.Module):\n",
    "    def __init__(self, embedding_dim=16, hidden_dim=64, vocab_size=vocab_size, num_layers=1, bidirectional=False):\n",
    "        super(LSTM, self).__init__()\n",
    "        self.embeding = nn.Embedding(vocab_size, embedding_dim)\n",
    "        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=num_layers, batch_first=True, bidirectional=bidirectional)\n",
    "        self.layer = nn.Linear(hidden_dim * (2 if bidirectional else 1), hidden_dim)\n",
    "        self.fc = nn.Linear(hidden_dim, 1)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # [bs, seq length]\n",
    "        x = self.embeding(x)\n",
    "        # [bs, seq length, embedding_dim] -> shape [bs, seq length，hidden_dim]\n",
    "        seq_output, (hidden, cell) = self.lstm(x)\n",
    "        # print(f'seq_output.shape{seq_output.shape}')\n",
    "        # print(f'hidden.shape{hidden.shape}') #最后一个时间步的输出\n",
    "        # print(f'cell.shape{cell.shape}') #最后一个时间步的cell state\n",
    "        # print(seq_output[:, -1, :].squeeze()==hidden.squeeze()) #squeeze() 去掉轴的尺寸为1的哪个轴\n",
    "        # print(seq_output[:, -1, :].squeeze()==cell.squeeze())\n",
    "        x = seq_output[:, -1, :]\n",
    "        # 取最后一个时间步的输出 (这也是为什么要设置padding_first=True的原因)\n",
    "        x = self.layer(x)\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "    \n",
    "sample_inputs = torch.randint(0, vocab_size, (2, 128))\n",
    "    \n",
    "print(\"{:=^80}\".format(\" 一层单向 LSTM \"))       \n",
    "for key, value in LSTM().named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T03:01:45.697591Z",
     "start_time": "2025-01-24T03:01:45.613064Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:30.829993Z",
     "iopub.status.busy": "2025-01-25T07:03:30.829853Z",
     "iopub.status.idle": "2025-01-25T07:03:30.973269Z",
     "shell.execute_reply": "2025-01-25T07:03:30.972789Z",
     "shell.execute_reply.started": "2025-01-25T07:03:30.829979Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([128, 1])\n"
     ]
    }
   ],
   "source": [
    "model = LSTM()\n",
    "#随机一个（128,500）的输入\n",
    "sample_inputs = torch.randint(0, vocab_size, (128, 500))\n",
    "sample_outputs = model(sample_inputs)\n",
    "print(sample_outputs.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-30T02:15:50.096207800Z",
     "start_time": "2024-07-30T02:15:50.080216700Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:30.975449Z",
     "iopub.status.busy": "2025-01-25T07:03:30.975087Z",
     "iopub.status.idle": "2025-01-25T07:03:30.978567Z",
     "shell.execute_reply": "2025-01-25T07:03:30.978046Z",
     "shell.execute_reply.started": "2025-01-25T07:03:30.975431Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4096"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "64*64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:36:09.545313600Z",
     "start_time": "2024-05-02T08:36:09.506335700Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:30.979231Z",
     "iopub.status.busy": "2025-01-25T07:03:30.979039Z",
     "iopub.status.idle": "2025-01-25T07:03:30.982074Z",
     "shell.execute_reply": "2025-01-25T07:03:30.981629Z",
     "shell.execute_reply.started": "2025-01-25T07:03:30.979217Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4096"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 * 16 * 64 #lstm.weight_ih_l0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-30T02:56:57.186572800Z",
     "start_time": "2024-07-30T02:56:57.168877900Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:30.982650Z",
     "iopub.status.busy": "2025-01-25T07:03:30.982498Z",
     "iopub.status.idle": "2025-01-25T07:03:30.985374Z",
     "shell.execute_reply": "2025-01-25T07:03:30.985005Z",
     "shell.execute_reply.started": "2025-01-25T07:03:30.982635Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8192"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "128*64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T03:03:33.941487Z",
     "start_time": "2025-01-24T03:03:33.937308Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:30.986132Z",
     "iopub.status.busy": "2025-01-25T07:03:30.985809Z",
     "iopub.status.idle": "2025-01-25T07:03:30.990868Z",
     "shell.execute_reply": "2025-01-25T07:03:30.990497Z",
     "shell.execute_reply.started": "2025-01-25T07:03:30.986117Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================== 一层双向 LSTM ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "           lstm.weight_ih_l0            paramerters num: 4096\n",
      "           lstm.weight_hh_l0            paramerters num: 16384\n",
      "            lstm.bias_ih_l0             paramerters num: 256\n",
      "            lstm.bias_hh_l0             paramerters num: 256\n",
      "       lstm.weight_ih_l0_reverse        paramerters num: 4096\n",
      "       lstm.weight_hh_l0_reverse        paramerters num: 16384\n",
      "        lstm.bias_ih_l0_reverse         paramerters num: 256\n",
      "        lstm.bias_hh_l0_reverse         paramerters num: 256\n",
      "              layer.weight              paramerters num: 8192\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "source": [
    "print(\"{:=^80}\".format(\" 一层双向 LSTM \"))\n",
    "for key, value in LSTM(bidirectional=True).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T03:04:05.259754Z",
     "start_time": "2025-01-24T03:04:05.255731Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:30.991474Z",
     "iopub.status.busy": "2025-01-25T07:03:30.991286Z",
     "iopub.status.idle": "2025-01-25T07:03:30.995665Z",
     "shell.execute_reply": "2025-01-25T07:03:30.995291Z",
     "shell.execute_reply.started": "2025-01-25T07:03:30.991459Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================== 两层单向 LSTM ===================================\n",
      "            embeding.weight             paramerters num: 160000\n",
      "           lstm.weight_ih_l0            paramerters num: 4096\n",
      "           lstm.weight_hh_l0            paramerters num: 16384\n",
      "            lstm.bias_ih_l0             paramerters num: 256\n",
      "            lstm.bias_hh_l0             paramerters num: 256\n",
      "           lstm.weight_ih_l1            paramerters num: 16384\n",
      "           lstm.weight_hh_l1            paramerters num: 16384\n",
      "            lstm.bias_ih_l1             paramerters num: 256\n",
      "            lstm.bias_hh_l1             paramerters num: 256\n",
      "              layer.weight              paramerters num: 4096\n",
      "               layer.bias               paramerters num: 64\n",
      "               fc.weight                paramerters num: 64\n",
      "                fc.bias                 paramerters num: 1\n"
     ]
    }
   ],
   "source": [
    "print(\"{:=^80}\".format(\" 两层单向 LSTM \"))\n",
    "for key, value in LSTM(num_layers=2).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T03:05:07.528779Z",
     "start_time": "2025-01-24T03:05:07.525030Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:30.996315Z",
     "iopub.status.busy": "2025-01-25T07:03:30.996073Z",
     "iopub.status.idle": "2025-01-25T07:03:30.998974Z",
     "shell.execute_reply": "2025-01-25T07:03:30.998568Z",
     "shell.execute_reply.started": "2025-01-25T07:03:30.996300Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4096"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "16*64*4 #4是4倍"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-24T03:05:23.241838Z",
     "start_time": "2025-01-24T03:05:23.239064Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:30.999669Z",
     "iopub.status.busy": "2025-01-25T07:03:30.999396Z",
     "iopub.status.idle": "2025-01-25T07:03:31.002414Z",
     "shell.execute_reply": "2025-01-25T07:03:31.001983Z",
     "shell.execute_reply.started": "2025-01-25T07:03:30.999654Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16384"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "64*64*4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-30T02:57:22.790960200Z",
     "start_time": "2024-07-30T02:57:22.446263Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:31.003202Z",
     "iopub.status.busy": "2025-01-25T07:03:31.002863Z",
     "iopub.status.idle": "2025-01-25T07:03:31.096122Z",
     "shell.execute_reply": "2025-01-25T07:03:31.095731Z",
     "shell.execute_reply.started": "2025-01-25T07:03:31.003186Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        # 二分类\n",
    "        preds = logits > 0\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TensorBoard 可视化\n",
    "\n",
    "\n",
    "训练过程中可以使用如下命令启动tensorboard服务。\n",
    "\n",
    "```shell\n",
    "tensorboard \\\n",
    "    --logdir=runs \\     # log 存放路径\n",
    "    --host 0.0.0.0 \\    # ip\n",
    "    --port 8848         # 端口\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:31.097339Z",
     "iopub.status.busy": "2025-01-25T07:03:31.096681Z",
     "iopub.status.idle": "2025-01-25T07:03:31.235988Z",
     "shell.execute_reply": "2025-01-25T07:03:31.235580Z",
     "shell.execute_reply.started": "2025-01-25T07:03:31.097309Z"
    }
   },
   "outputs": [],
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save Best\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:31.236998Z",
     "iopub.status.busy": "2025-01-25T07:03:31.236569Z",
     "iopub.status.idle": "2025-01-25T07:03:31.241884Z",
     "shell.execute_reply": "2025-01-25T07:03:31.241362Z",
     "shell.execute_reply.started": "2025-01-25T07:03:31.236968Z"
    }
   },
   "outputs": [],
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Early Stop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:31.242903Z",
     "iopub.status.busy": "2025-01-25T07:03:31.242540Z",
     "iopub.status.idle": "2025-01-25T07:03:31.247031Z",
     "shell.execute_reply": "2025-01-25T07:03:31.246495Z",
     "shell.execute_reply.started": "2025-01-25T07:03:31.242874Z"
    }
   },
   "outputs": [],
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-25T07:03:31.248093Z",
     "iopub.status.busy": "2025-01-25T07:03:31.247846Z",
     "iopub.status.idle": "2025-01-25T07:05:41.252542Z",
     "shell.execute_reply": "2025-01-25T07:05:41.252112Z",
     "shell.execute_reply.started": "2025-01-25T07:03:31.248066Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 3920/3920 [02:08<00:00, 30.62it/s, epoch=19]\n"
     ]
    }
   ],
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits > 0\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 20\n",
    "\n",
    "model = LSTM()\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失 (但是二分类)\n",
    "loss_fct = F.binary_cross_entropy_with_logits\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/imdb-lstm\")\n",
    "# tensorboard_callback.draw_model(model, [1, MAX_LENGTH])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/imdb-lstm\", save_step=len(train_dl), save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_dl, \n",
    "    test_dl, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-25T07:05:41.253463Z",
     "iopub.status.busy": "2025-01-25T07:05:41.253084Z",
     "iopub.status.idle": "2025-01-25T07:05:41.676441Z",
     "shell.execute_reply": "2025-01-25T07:05:41.675870Z",
     "shell.execute_reply.started": "2025-01-25T07:05:41.253443Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10)  #横坐标是 steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-25T07:05:41.677231Z",
     "iopub.status.busy": "2025-01-25T07:05:41.677010Z",
     "iopub.status.idle": "2025-01-25T07:05:44.693760Z",
     "shell.execute_reply": "2025-01-25T07:05:44.693161Z",
     "shell.execute_reply.started": "2025-01-25T07:05:41.677205Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_430/1661179837.py:4: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  model.load_state_dict(torch.load(\"checkpoints/imdb-lstm/best.ckpt\", map_location=\"cpu\"))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3768\n",
      "accuracy: 0.8639\n"
     ]
    }
   ],
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/imdb-lstm/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, test_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
